1. Field of the Invention
Embodiments of the present invention relate generally to computer graphics and more specifically a system and method for transferring data between unrelated application programming interface (API) contexts on one or more graphics processing units (CPUs).
2. Description of the Related Art
Computer graphics image data typically undergoes several processing steps before each graphics frame is completely rendered for display or storage. Each processing step typically operates on graphics image data utilizing programming steps defined through an application programming interface, enabling the graphics application to utilize high performance hardware such as a graphics processing unit (GPU) to execute a set of processing steps with minimal real-time supervision from a host CPU. For example, a graphics application executing on a host central processing unit (CPU) may use an application programming interface to program processing steps in a GPU including physics, geometric transform, polygon setup, rasterization and pixel shading, resulting in the display of graphics image frames.
As graphics applications become more sophisticated, the related processing steps are becoming more sophisticated and diverse in nature. The growing diversity of functional requirements by graphics applications results in situations where certain application programming interfaces are more suitable for certain types of processing steps relative to other application programming interfaces. However, the current art only provides for single application programming interfaces to operate on data in a single application programming interface context. The requirement that all processing steps must be defined and executed within a single application programming interface context severely limits the ability of new graphics applications to exploit the potential of newly emerging application programming interfaces.
In addition, as graphics applications begin to implement more steps with greater complexity in each step, the computational load on the GPU executing the processing steps increases, resulting in diminished overall rendering performance. One approach to improving overall processing time has been to configure multiple GPUs to concurrently process a single graphics frame or assign multiple GPUs to process alternating graphics frames. Such approaches generally involve synchronizing the GPUs to simultaneously render portions of the same frame or sequential frames to increase overall rendering performance. Again, however, in current multi-GPU systems, all of the GPUs have to specify their complete rendering pipelines within the same application programming interface and therefore cannot optimally select and utilize more suitable application programming interfaces, as needed, for each processing step.
As the foregoing illustrates, what is needed in the art is a mechanism for enabling applications to exploit different application programming interfaces when processing operations are performed on one or more GPUs.